home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 16 / CU Amiga Magazine's Super CD-ROM 16 (1997-10-16)(EMAP Images)(GB)[!][issue 1997-11].iso / CUCD / Graphics / Ghostscript / source / gdevegaa.asm < prev    next >
Assembly Source File  |  1994-07-27  |  7KB  |  278 lines
  1. ;    Copyright (C) 1989, 1992 Aladdin Enterprises.  All rights reserved.
  2. ; 
  3. ; This file is part of Aladdin Ghostscript.
  4. ; 
  5. ; Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. ; or distributor accepts any responsibility for the consequences of using it,
  7. ; or for whether it serves any particular purpose or works at all, unless he
  8. ; or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. ; License (the "License") for full details.
  10. ; 
  11. ; Every copy of Aladdin Ghostscript must include a copy of the License,
  12. ; normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. ; the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. ; under certain conditions described in the License.  Among other things, the
  15. ; License requires that the copyright notice and this notice be preserved on
  16. ; all copies.
  17.  
  18. ; gdevegaasm.asm
  19. ; Assembly code for Ghostscript PC frame buffer driver
  20.  
  21. gdevegaasm_TEXT    SEGMENT    BYTE PUBLIC 'CODE'
  22.     ASSUME    CS:gdevegaasm_TEXT
  23.  
  24. ; Note: Turbo C uses si and di for register variables, so
  25. ; we have to preserve them.
  26.  
  27. ; Normal entry and exit.  Arguments are relative to bp.
  28. enterp    macro
  29.     push    bp
  30.     mov    bp,sp
  31.     x = 6                ; offset of arguments,
  32.                     ; large code model
  33.     endm
  34. leavep    macro
  35.     pop    bp
  36.     endm
  37. ; Fast entry and exit, for procedures that don't use bx until
  38. ; they've fetched all their arguments.  Arguments are relative to ss:bx.
  39. enterf    macro
  40.     mov    bx,sp
  41.     x = 4                ; offset of arguments,
  42.                     ; large code model
  43.     endm
  44. leavef    macro
  45.     endm
  46.  
  47. ; Fast call to VESA set-page routine.
  48. ; void vesa_call_set_page(void (*set_page_proc)(int), int page_no, int win_no)
  49.     PUBLIC    _vesa_call_set_page
  50. _vesa_call_set_page proc far
  51.     enterf
  52.     mov ax,4f05h
  53.     mov dx,ss:[bx+x+4]            ; page_no
  54.     push ss:[bx+x+2]            ; set_page_proc
  55.     push ss:[bx+x]
  56.     mov bx,ss:[bx+x+6]            ; win_no
  57.     ret
  58. _vesa_call_set_page endp
  59.  
  60. ; Structure for operation parameters.
  61. ; Note that this structure is shared with C code.
  62. ; Not all parameters are used for every operation.
  63. ; typedef struct rop_params_s {
  64. p_dest    equ    0    ; fb_ptr dest;    /* pointer to frame buffer */
  65. p_draster equ    4    ; int draster;    /* raster of frame buffer */
  66. p_src    equ    6    ; const byte far *src; /* pointer to source data */
  67. p_sraster equ    10    ; int sraster;    /* source raster */
  68. p_width    equ    12    ; int width;    /* width in bytes */
  69. p_height equ    14    ; int height;    /* height in scan lines */
  70. p_shift equ    16    ; int shift;    /* amount to right shift source */
  71. p_invert equ    18    ; int invert;    /* 0 or -1 to invert source */
  72. p_data    equ    20    ; int data;    /* data for fill */
  73. ; } rop_params;
  74.  
  75. ; void memsetcol(rop_params _ss *rop)
  76. ; {    byte far *addr = rop->dest;
  77. ;    int yc = rop->height;
  78. ;    while ( yc-- )
  79. ;     { byte discard = *addr;
  80. ;       *addr = rop->data;
  81. ;       addr += rop->draster;
  82. ;     }
  83. ; }
  84.     PUBLIC    _memsetcol
  85. _memsetcol proc    far
  86.     enterf
  87.     push    ds
  88.     mov    ax,ss
  89.     mov    ds,ax
  90.     mov    bx,[bx+x]            ; rop
  91.     mov    cx,[bx].p_height
  92.     jcxz    msc0                ; height == 0
  93.     mov    ax,[bx].p_data
  94.     mov    dx,[bx].p_draster
  95.     lds    bx,[bx].p_dest
  96. ; Unroll the loop -- two copies.
  97.     inc    cx        ;round up to nearest word.  cx>=2 now.
  98.     shr    cx,1        ;make byte count into word count.
  99.     jnc    msc2        ;if it had been odd, do a half word first.
  100. msc1:    mov    ah,[bx]
  101.     mov    [bx],al
  102.     add    bx,dx
  103. msc2:    mov    ah,[bx]
  104.     mov    [bx],al
  105.     add    bx,dx
  106.     loop    msc1
  107.     pop    ds
  108. msc0:    leavef
  109.     ret
  110. _memsetcol ENDP
  111.  
  112. ; void memsetrect(rop_params _ss *rop)
  113. ; {    byte far *addr = rop->dest;
  114. ;    int yc = rop->height;
  115. ;    while ( yc-- )
  116. ;     { int cnt = rop->width;
  117. ;       while ( cnt-- ) *addr++ = rop->data;
  118. ;       addr += rop->drast - rop->width;
  119. ;     }
  120. ; }
  121.     PUBLIC    _memsetrect
  122. _memsetrect proc    far
  123.     enterf
  124.     push    ds
  125.     mov    ax,ss
  126.     mov    ds,ax
  127.     mov    bx,[bx+x]            ; rop
  128.     mov    cx,[bx].p_height
  129.     jcxz    msr0                ; height == 0
  130.     push    si
  131.     push    di
  132.     mov    ax,[bx].p_data
  133.     les    di,[bx].p_dest
  134.     cld
  135.     mov    dx,[bx].p_draster
  136.     mov    si,cx                ; si = height
  137.     mov    cx,[bx].p_width
  138.     sub    dx,cx
  139.     cmp    cx,10
  140.     ja    msrl                ; large count, use fast loop
  141. ; Small count, rep stosb is faster.
  142. msrs:    mov    cx,[bx].p_width
  143.     rep    stosb
  144.     add    di,dx
  145.     dec    si                ; count reps
  146.     jnz    msrs
  147.     pop    di
  148.     pop    si
  149. msr0:    pop    ds
  150.     leavef
  151.     ret
  152. ; Large count, loop by words rather than bytes.
  153. msrl:    mov    ah,al            ;we may be storing words...
  154. msr1:    mov    cx,[bx].p_width
  155.     test    di,1            ;test for an even address
  156.     je    msr2            ;if even, we can store words.
  157.     stosb                ;otherwise we need to even it out.
  158.     dec    cx            ;(cx is at least one here)
  159. msr2:    shr    cx,1            ;convert byte count into word count
  160.     rep    stosw            ;store them puppies as fast as we can.
  161.     jnc    msr3            ;if an odd number, store it, too.
  162.     stosb                ;(no need to dec cx here).
  163. msr3:    add    di,dx
  164.     dec    si            ; count reps
  165.     jnz    msr1
  166.     pop    di
  167.     pop    si
  168.     pop    ds
  169.     leavef
  170.     ret
  171. _memsetrect ENDP
  172.  
  173. ; void memrwcol(rop_params _ss *rop)
  174. ; {    byte far *dp = rop->dest;
  175. ;    const byte far *sp = rop->src;
  176. ;    int yc = rop->height;
  177. ;    int shift = rop->shift;
  178. ;    while ( yc-- )
  179. ;     { byte discard = *dp;
  180. ;       *dp = ((*sp >> shift) + (*sp << (8 - shift))) ^ rop->invert;
  181. ;       dp += rop->draster, sp += rop->sraster;
  182. ;     }
  183. ; }
  184.     PUBLIC    _memrwcol
  185. _memrwcol proc far
  186.     enterp
  187.     push    ds
  188.     mov    ax,ss
  189.     mov    ds,ax
  190.     mov    bx,[bp+x]            ; rop
  191.     cmp    word ptr [bx].p_height,0
  192.     jz    short mrw0
  193.     push    si
  194.     push    di
  195. ; Register usage:
  196. ;   ds:si = sp, es:di = dp, bx = sraster, dx = draster, cl = shift,
  197. ;   ch = invert, ah = low byte of yc.
  198.     push    [bx].p_height
  199.     mov    dx,[bx].p_draster
  200.     mov    ax,[bx].p_sraster
  201.     mov    cl,[bx].p_shift
  202.     mov    ch,[bx].p_invert
  203.     les    di,[bx].p_dest
  204.     lds    si,[bx].p_src
  205.     mov    bx,ax
  206.     mov    ah,[bp-8]            ; low byte of yc
  207.     test    ah,ah
  208.     jz    mrw2
  209. mrw1:    mov    al,[si]
  210.     ror    al,cl
  211.     xor    al,ch
  212.     xchg    es:[di],al
  213.     add    si,bx
  214.     add    di,dx
  215.     dec    ah
  216.     jnz    mrw1
  217. mrw2:    dec    byte ptr [bp-7]            ; high byte of yc
  218.     jge    mrw1
  219.     add    sp,2                ; pop yc
  220.     pop    di
  221.     pop    si
  222. mrw0:    pop    ds
  223.     leavep
  224.     ret
  225. _memrwcol ENDP
  226.  
  227. ; void memrwcol2(rop_params _ss *rop)
  228. ; {    byte far *dp = rop->dest;
  229. ;    const byte far *sp = rop->src;
  230. ;    int yc = rop->height;
  231. ;    int shift = rop->shift;
  232. ;    while ( yc-- )
  233. ;     { byte discard = *dp;
  234. ;       *dp = ((sp[1] >> shift) + (*sp << (8 - shift))) ^ rop->invert;
  235. ;       dp += rop->draster, sp += rop->sraster;
  236. ;     }
  237. ; }
  238.     PUBLIC    _memrwcol2
  239. _memrwcol2 proc far
  240.     enterp
  241.     push    ds
  242.     mov    ax,ss
  243.     mov    ds,ax
  244.     mov    bx,[bp+x]            ; rop
  245.     cmp    word ptr [bx].p_height,0
  246.     jz    short mrw20
  247.     push    si
  248.     push    di
  249. ; Register usage:
  250. ;   ds:si = sp, es:di = dp, bx = sraster, dx = draster, cl = shift,
  251. ;   ch = invert.
  252.     push    [bx].p_height
  253.     mov    dx,[bx].p_draster
  254.     mov    ax,[bx].p_sraster
  255.     mov    cl,[bx].p_shift
  256.     mov    ch,[bx].p_invert
  257.     les    di,[bx].p_dest
  258.     lds    si,[bx].p_src
  259.     mov    bx,ax
  260. mrw21:    mov    ax,[si]                ; bytes are in wrong order...
  261.     ror    ax,cl
  262.     xor    ah,ch                ; ... so result is in ah
  263.     xchg    es:[di],ah
  264.     add    si,bx
  265.     add    di,dx
  266.     dec    word ptr [bp-8]            ; yc
  267.     jg    mrw21
  268.     add    sp,2                ; pop yc
  269.     pop    di
  270.     pop    si
  271. mrw20:    pop    ds
  272.     leavep
  273.     ret
  274. _memrwcol2 ENDP
  275.  
  276. gdevegaasm_TEXT    ENDS
  277.     END
  278.